Datasets
Models
Downloads: 1
1357 lines (1357 with data), 191.7 kB
{
"cells": [
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"id": "in3VVDRqlMUE",
"tags": [],
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"outputId": "8f73c075-886e-4568-a28f-f02419216938"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Time in seconds since beginning of run: 1700501338.8948317\n",
"Mon Nov 20 17:28:58 2023\n"
]
}
],
"source": [
"# This cell is added by sphinx-gallery\n",
"# It can be customized to whatever you like\n",
"%matplotlib inline\n",
"# !pip install pennylane\n",
"# !pip install neural_tangents\n",
"# !pip install networkx\n",
"import time\n",
"seconds = time.time()\n",
"print(\"Time in seconds since beginning of run:\", seconds)\n",
"local_time = time.ctime(seconds)\n",
"print(local_time)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "cfjAkbwNlMUF"
},
"source": [
"Machine learning for quantum many-body problems\n",
"===============================================\n",
"\n",
"::: {.meta}\n",
":property=\\\"og:description\\\": Machine learning for many-body problems\n",
":property=\\\"og:image\\\":\n",
"<https://pennylane.ai/qml/_images/ml_classical_shadow.png>\n",
":::\n",
"\n",
"::: {.related}\n",
"tutorial\\_classical\\_shadows Classical Shadows\n",
"tutorial\\_kernel\\_based\\_training Kernel-based training with\n",
"scikit-learn tutorial\\_kernels\\_module Training and evaluating quantum\n",
"kernels\n",
":::\n",
"\n",
"*Author: Utkarsh Azad --- Posted: 02 May 2022. Last Updated: 09 May\n",
"2022*\n",
"\n",
"Storing and processing a complete description of an $n$-qubit quantum\n",
"mechanical system is challenging because the amount of memory required\n",
"generally scales exponentially with the number of qubits. The quantum\n",
"community has recently addressed this challenge by using the\n",
"`classical shadow <tutorial_classical_shadows>`{.interpreted-text\n",
"role=\"doc\"} formalism, which allows us to build more concise classical\n",
"descriptions of quantum states using randomized single-qubit\n",
"measurements. It was argued in Ref. that combining classical shadows\n",
"with classical machine learning enables using learning models that\n",
"efficiently predict properties of the quantum systems, such as the\n",
"expectation value of a Hamiltonian, correlation functions, and\n",
"entanglement entropies.\n",
"\n",
"{.align-center\n",
"width=\"80.0%\"}\n",
"\n",
"In this demo, we describe one of the ideas presented in Ref. for using\n",
"classical shadow formalism and machine learning to predict the\n",
"ground-state properties of the 2D antiferromagnetic Heisenberg model. We\n",
"begin by learning how to build the Heisenberg model, calculate its\n",
"ground-state properties, and compute its classical shadow. Finally, we\n",
"demonstrate how to use\n",
"`kernel-based learning models <tutorial_kernels_module>`{.interpreted-text\n",
"role=\"doc\"} to predict ground-state properties from the learned\n",
"classical shadows. So let\\'s get started!\n",
"\n",
"Building the 2D Heisenberg Model\n",
"--------------------------------\n",
"\n",
"We define a two-dimensional antiferromagnetic [Heisenberg\n",
"model](https://en.wikipedia.org/wiki/Quantum_Heisenberg_model) as a\n",
"square lattice, where a spin-1/2 particle occupies each site. The\n",
"antiferromagnetic nature and the overall physics of this model depend on\n",
"the couplings $J_{ij}$ present between the spins, as reflected in the\n",
"Hamiltonian associated with the model:\n",
"\n",
"$$H = \\sum_{i < j} J_{ij}(X_i X_j + Y_i Y_j + Z_i Z_j) .$$\n",
"\n",
"Here, we consider the family of Hamiltonians where all the couplings\n",
"$J_{ij}$ are sampled uniformly from \\[0, 2\\]. We build a coupling matrix\n",
"$J$ by providing the number of rows $N_r$ and columns $N_c$ present in\n",
"the square lattice. The dimensions of this matrix are $N_s \\times N_s$,\n",
"where $N_s = N_r \\times N_c$ is the total number of spin particles\n",
"present in the model.\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"id": "LWfXJdIBlMUG"
},
"outputs": [],
"source": [
"import itertools as it\n",
"import pennylane.numpy as np\n",
"import numpy as anp\n",
"\n",
"def build_coupling_mats(num_mats, num_rows, num_cols):\n",
" num_spins = num_rows * num_cols\n",
" coupling_mats = np.zeros((num_mats, num_spins, num_spins))\n",
" coup_terms = anp.random.RandomState(24).uniform(0, 2,\n",
" size=(num_mats, 2 * num_rows * num_cols - num_rows - num_cols))\n",
" # populate edges to build the grid lattice\n",
" edges = [(si, sj) for (si, sj) in it.combinations(range(num_spins), 2)\n",
" if sj % num_cols and sj - si == 1 or sj - si == num_cols]\n",
" for itr in range(num_mats):\n",
" for ((i, j), term) in zip(edges, coup_terms[itr]):\n",
" coupling_mats[itr][i][j] = coupling_mats[itr][j][i] = term\n",
" return coupling_mats"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ZV-J9mFJlMUG"
},
"source": [
"For this demo, we study a model with four spins arranged on the nodes of\n",
"a square lattice. We require four qubits for simulating this model; one\n",
"qubit for each spin. We start by building a coupling matrix `J_mat`\n",
"using our previously defined function.\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"id": "GSqBR9p2lMUG"
},
"outputs": [],
"source": [
"Nr, Nc = 2, 2\n",
"num_qubits = Nr * Nc # Ns\n",
"J_mat = build_coupling_mats(1, Nr, Nc)[0]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LMJScKXHlMUG"
},
"source": [
"We can now visualize the model instance by representing the coupling\n",
"matrix as a `networkx` graph:\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 436
},
"id": "PnCxl2OUlMUH",
"outputId": "e755b5df-6614-4b8a-c973-8ee7743a2722"
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 400x400 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"import networkx as nx\n",
"\n",
"G = nx.from_numpy_array(np.matrix(J_mat), create_using=nx.DiGraph)\n",
"pos = {i: (i % Nc, -(i // Nc)) for i in G.nodes()}\n",
"edge_labels = {(x, y): np.round(J_mat[x, y], 2) for x, y in G.edges()}\n",
"weights = [x + 1.5 for x in list(nx.get_edge_attributes(G, \"weight\").values())]\n",
"\n",
"plt.figure(figsize=(4, 4))\n",
"nx.draw(\n",
" G, pos, node_color=\"lightblue\", with_labels=True,\n",
" node_size=600, width=weights, edge_color=\"firebrick\",\n",
")\n",
"nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=edge_labels)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "t0E6JAIIlMUH"
},
"source": [
"We then use the same coupling matrix `J_mat` to obtain the Hamiltonian\n",
"$H$ for the model we have instantiated above.\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "A_XDopwwlMUH",
"outputId": "23484c75-57e6-4105-a263-976eb66ffc41"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Hamiltonian =\n",
" (0.44013459956570355) [X2 X3]\n",
"+ (0.44013459956570355) [Y2 Y3]\n",
"+ (0.44013459956570355) [Z2 Z3]\n",
"+ (1.399024099899152) [X0 X2]\n",
"+ (1.399024099899152) [Y0 Y2]\n",
"+ (1.399024099899152) [Z0 Z2]\n",
"+ (1.920034606671837) [X0 X1]\n",
"+ (1.920034606671837) [Y0 Y1]\n",
"+ (1.920034606671837) [Z0 Z1]\n",
"+ (1.9997345852477584) [X1 X3]\n",
"+ (1.9997345852477584) [Y1 Y3]\n",
"+ (1.9997345852477584) [Z1 Z3]\n"
]
}
],
"source": [
"import pennylane as qml\n",
"\n",
"def Hamiltonian(J_mat):\n",
" coeffs, ops = [], []\n",
" ns = J_mat.shape[0]\n",
" for i, j in it.combinations(range(ns), r=2):\n",
" coeff = J_mat[i, j]\n",
" if coeff:\n",
" for op in [qml.PauliX, qml.PauliY, qml.PauliZ]:\n",
" coeffs.append(coeff)\n",
" ops.append(op(i) @ op(j))\n",
" H = qml.Hamiltonian(coeffs, ops)\n",
" return H\n",
"\n",
"print(f\"Hamiltonian =\\n{Hamiltonian(J_mat)}\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "JD6aZtNilMUH"
},
"source": [
"For the Heisenberg model, a property of interest is usually the two-body\n",
"correlation function $C_{ij}$, which for a pair of spins $i$ and $j$ is\n",
"defined as the following operator:\n",
"\n",
"$$\\hat{C}_{ij} = \\frac{1}{3} (X_i X_j + Y_iY_j + Z_iZ_j).$$\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"id": "UVBY4jUglMUH"
},
"outputs": [],
"source": [
"def corr_function(i, j):\n",
" ops = []\n",
" for op in [qml.PauliX, qml.PauliY, qml.PauliZ]:\n",
" if i != j:\n",
" ops.append(op(i) @ op(j))\n",
" else:\n",
" ops.append(qml.Identity(i))\n",
" return ops"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "O0-ZNiNXlMUH"
},
"source": [
"The expectation value of each such operator $\\hat{C}_{ij}$ with respect\n",
"to the ground state $|\\psi_{0}\\rangle$ of the model can be used to build\n",
"the correlation matrix $C$:\n",
"\n",
"$${C}_{ij} = \\langle \\hat{C}_{ij} \\rangle = \\frac{1}{3} \\langle \\psi_{0} | X_i X_j + Y_iY_j + Z_iZ_j | \\psi_{0} \\rangle .$$\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "VhgAsFyJlMUH"
},
"source": [
"Hence, to build $C$ for the model, we need to calculate its ground state\n",
"$|\\psi_{0}\\rangle$. We do this by diagonalizing the Hamiltonian for the\n",
"model. Then, we obtain the eigenvector corresponding to the smallest\n",
"eigenvalue.\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"id": "W-r82wjjlMUH"
},
"outputs": [],
"source": [
"import scipy as sp\n",
"\n",
"ham = Hamiltonian(J_mat)\n",
"eigvals, eigvecs = sp.sparse.linalg.eigs(ham.sparse_matrix())\n",
"psi0 = eigvecs[:, np.argmin(eigvals)]"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Bft7PBtVlMUH"
},
"source": [
"We then build a circuit that initializes the qubits into the ground\n",
"state and measures the expectation value of the provided set of\n",
"observables.\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"id": "aMmNdfzAlMUH"
},
"outputs": [],
"source": [
"dev_exact = qml.device(\"lightning.qubit\", wires=num_qubits) # for exact simulation\n",
"\n",
"def circuit(psi, observables):\n",
" psi = psi / np.linalg.norm(psi) # normalize the state\n",
" qml.QubitStateVector(psi, wires=range(num_qubits))\n",
" return [qml.expval(o) for o in observables]\n",
"\n",
"circuit_exact = qml.QNode(circuit, dev_exact)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "7_OTMOuMlMUH"
},
"source": [
"Finally, we execute this circuit to obtain the exact correlation matrix\n",
"$C$. We compute the correlation operators $\\hat{C}_{ij}$ and their\n",
"expectation values with respect to the ground state $|\\psi_0\\rangle$.\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"id": "M2SqFe0IlMUI"
},
"outputs": [],
"source": [
"coups = list(it.product(range(num_qubits), repeat=2))\n",
"corrs = [corr_function(i, j) for i, j in coups]\n",
"\n",
"def build_exact_corrmat(coups, corrs, circuit, psi):\n",
" corr_mat_exact = np.zeros((num_qubits, num_qubits))\n",
" for idx, (i, j) in enumerate(coups):\n",
" corr = corrs[idx]\n",
" if i == j:\n",
" corr_mat_exact[i][j] = 1.0\n",
" else:\n",
" corr_mat_exact[i][j] = (\n",
" np.sum(np.array([circuit(psi, observables=[o]) for o in corr]).T) / 3\n",
" )\n",
" corr_mat_exact[j][i] = corr_mat_exact[i][j]\n",
" return corr_mat_exact\n",
"\n",
"expval_exact = build_exact_corrmat(coups, corrs, circuit_exact, psi0)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "wRhl6GSvlMUI"
},
"source": [
"Once built, we can visualize the correlation matrix:\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 337
},
"id": "elPohZB_lMUI",
"outputId": "6880e8b9-aa60-4780-9263-ea2cdd559d0f"
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 400x400 with 2 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"fig, ax = plt.subplots(1, 1, figsize=(4, 4))\n",
"im = ax.imshow(expval_exact, cmap=plt.get_cmap(\"RdBu\"), vmin=-1, vmax=1)\n",
"ax.xaxis.set_ticks(range(num_qubits))\n",
"ax.yaxis.set_ticks(range(num_qubits))\n",
"ax.xaxis.set_tick_params(labelsize=14)\n",
"ax.yaxis.set_tick_params(labelsize=14)\n",
"ax.set_title(\"Exact Correlation Matrix\", fontsize=14)\n",
"\n",
"bar = fig.colorbar(im, pad=0.05, shrink=0.80 )\n",
"bar.set_label(r\"$C_{ij}$\", fontsize=14, rotation=0)\n",
"bar.ax.tick_params(labelsize=14)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "X7AxsPAnlMUI"
},
"source": [
"Constructing Classical Shadows\n",
"==============================\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "NTPT4XUFlMUI"
},
"source": [
"Now that we have built the Heisenberg model, the next step is to\n",
"construct a\n",
"`classical shadow <tutorial_classical_shadows>`{.interpreted-text\n",
"role=\"doc\"} representation for its ground state. To construct an\n",
"approximate classical representation of an $n$-qubit quantum state\n",
"$\\rho$, we perform randomized single-qubit measurements on $T$-copies of\n",
"$\\rho$. Each measurement is chosen randomly among the Pauli bases $X$,\n",
"$Y$, or $Z$ to yield random $n$ pure product states $|s_i\\rangle$ for\n",
"each copy:\n",
"\n",
"$$|s_{i}^{(t)}\\rangle \\in \\{|0\\rangle, |1\\rangle, |+\\rangle, |-\\rangle, |i+\\rangle, |i-\\rangle\\}.$$\n",
"\n",
"$$S_T(\\rho) = \\big\\{|s_{i}^{(t)}\\rangle: i\\in\\{1,\\ldots, n\\},\\ t\\in\\{1,\\ldots, T\\} \\big\\}.$$\n",
"\n",
"Each of the $|s_i^{(t)}\\rangle$ provides us with a snapshot of the state\n",
"$\\rho$, and the $nT$ measurements yield the complete set $S_{T}$, which\n",
"requires just $3nT$ bits to be stored in classical memory. This is\n",
"discussed in further detail in our previous demo about\n",
"`classical shadows <tutorial_classical_shadows>`{.interpreted-text\n",
"role=\"doc\"}.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "voRlU_8blMUI"
},
"source": [
"{.align-center\n",
"width=\"100.0%\"}\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nJd4CxtClMUI"
},
"source": [
"To prepare a classical shadow for the ground state of the Heisenberg\n",
"model, we simply reuse the circuit template used above and reconstruct a\n",
"`QNode` utilizing a device that performs single-shot measurements.\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"id": "puR1Cx8WlMUI"
},
"outputs": [],
"source": [
"dev_oshot = qml.device(\"lightning.qubit\", wires=num_qubits, shots=1)\n",
"circuit_oshot = qml.QNode(circuit, dev_oshot)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "729nluzslMUI"
},
"source": [
"Now, we define a function to build the classical shadow for the quantum\n",
"state prepared by a given $n$-qubit circuit using $T$-copies of\n",
"randomized Pauli basis measurements\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "2lKMEDwRlMUI",
"outputId": "964efa4e-b3df-42b8-911e-cf5df8388de5"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"First five measurement outcomes =\n",
" [[ 1. -1. -1. 1.]\n",
" [ 1. -1. -1. -1.]\n",
" [-1. 1. 1. 1.]\n",
" [ 1. 1. -1. -1.]\n",
" [-1. 1. 1. -1.]]\n",
"First five measurement bases =\n",
" [[1 1 2 2]\n",
" [2 0 0 2]\n",
" [1 0 2 2]\n",
" [0 2 0 2]\n",
" [2 1 0 1]]\n"
]
}
],
"source": [
"def gen_class_shadow(circ_template, circuit_params, num_shadows, num_qubits):\n",
" # prepare the complete set of available Pauli operators\n",
" unitary_ops = [qml.PauliX, qml.PauliY, qml.PauliZ]\n",
" # sample random Pauli measurements uniformly\n",
" unitary_ensmb = np.random.randint(0, 3, size=(num_shadows, num_qubits), dtype=int)\n",
"\n",
" outcomes = np.zeros((num_shadows, num_qubits))\n",
" for ns in range(num_shadows):\n",
" # for each snapshot, extract the Pauli basis measurement to be performed\n",
" meas_obs = [unitary_ops[unitary_ensmb[ns, i]](i) for i in range(num_qubits)]\n",
" # perform single shot randomized Pauli measuremnt for each qubit\n",
" outcomes[ns, :] = circ_template(circuit_params, observables=meas_obs)\n",
"\n",
" return outcomes, unitary_ensmb\n",
"\n",
"\n",
"outcomes, basis = gen_class_shadow(circuit_oshot, psi0, 100, num_qubits)\n",
"print(\"First five measurement outcomes =\\n\", outcomes[:5])\n",
"print(\"First five measurement bases =\\n\", basis[:5])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "aM9kSgoElMUI"
},
"source": [
"Furthermore, $S_{T}$ can be used to construct an approximation of the\n",
"underlying $n$-qubit state $\\rho$ by averaging over $\\sigma_t$:\n",
"\n",
"$$\\sigma_T(\\rho) = \\frac{1}{T} \\sum_{1}^{T} \\big(3|s_{1}^{(t)}\\rangle\\langle s_1^{(t)}| - \\mathbb{I}\\big)\\otimes \\ldots \\otimes \\big(3|s_{n}^{(t)}\\rangle\\langle s_n^{(t)}| - \\mathbb{I}\\big).$$\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"id": "uhlXzt7IlMUI"
},
"outputs": [],
"source": [
"def snapshot_state(meas_list, obs_list):\n",
" # undo the rotations done for performing Pauli measurements in the specific basis\n",
" rotations = [\n",
" qml.matrix(qml.Hadamard(wires=0)), # X-basis\n",
" qml.matrix(qml.Hadamard(wires=0)) @ qml.matrix(qml.adjoint(qml.S(wires=0))), # Y-basis\n",
" qml.matrix(qml.Identity(wires=0)), # Z-basis\n",
" ]\n",
"\n",
" # reconstruct snapshot from local Pauli measurements\n",
" rho_snapshot = [1]\n",
" for meas_out, basis in zip(meas_list, obs_list):\n",
" # preparing state |s_i><s_i| using the post measurement outcome:\n",
" # |0><0| for 1 and |1><1| for -1\n",
" state = np.array([[1, 0], [0, 0]]) if meas_out == 1 else np.array([[0, 0], [0, 1]])\n",
" local_rho = 3 * (rotations[basis].conj().T @ state @ rotations[basis]) - np.eye(2)\n",
" rho_snapshot = np.kron(rho_snapshot, local_rho)\n",
"\n",
" return rho_snapshot\n",
"\n",
"def shadow_state_reconst(shadow):\n",
" num_snapshots, num_qubits = shadow[0].shape\n",
" meas_lists, obs_lists = shadow\n",
"\n",
" # Reconstruct the quantum state from its classical shadow\n",
" shadow_rho = np.zeros((2 ** num_qubits, 2 ** num_qubits), dtype=complex)\n",
" for i in range(num_snapshots):\n",
" shadow_rho += snapshot_state(meas_lists[i], obs_lists[i])\n",
"\n",
" return shadow_rho / num_snapshots"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "wB7CZQJXlMUI"
},
"source": [
"To see how well the reconstruction works for different values of $T$, we\n",
"look at the\n",
"[fidelity](https://en.wikipedia.org/wiki/Fidelity_of_quantum_states) of\n",
"the actual quantum state with respect to the reconstructed quantum state\n",
"from the classical shadow with $T$ copies. On average, as the number of\n",
"copies $T$ is increased, the reconstruction becomes more effective with\n",
"average higher fidelity values (orange) and lower variance (blue).\n",
"Eventually, in the limit $T\\rightarrow\\infty$, the reconstruction will\n",
"be exact.\n",
"\n",
"{.align-center\n",
"width=\"80.0%\"}\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "KuzuhucBlMUI"
},
"source": [
"The reconstructed quantum state $\\sigma_T$ can also be used to evaluate\n",
"expectation values $\\text{Tr}(O\\sigma_T)$ for some localized observable\n",
"$O = \\bigotimes_{i}^{n} P_i$, where $P_i \\in \\{I, X, Y, Z\\}$. However,\n",
"as shown above, $\\sigma_T$ would be only an approximation of $\\rho$ for\n",
"finite values of $T$. Therefore, to estimate $\\langle O \\rangle$\n",
"robustly, we use the median of means estimation. For this purpose, we\n",
"split up the $T$ shadows into $K$ equally-sized groups and evaluate the\n",
"median of the mean value of $\\langle O \\rangle$ for each of these\n",
"groups.\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"id": "29rEs_S1lMUI"
},
"outputs": [],
"source": [
"def estimate_shadow_obs(shadow, observable, k=10):\n",
" shadow_size = shadow[0].shape[0]\n",
"\n",
" # convert Pennylane observables to indices\n",
" map_name_to_int = {\"PauliX\": 0, \"PauliY\": 1, \"PauliZ\": 2}\n",
" if isinstance(observable, (qml.PauliX, qml.PauliY, qml.PauliZ)):\n",
" target_obs = np.array([map_name_to_int[observable.name]])\n",
" target_locs = np.array([observable.wires[0]])\n",
" else:\n",
" target_obs = np.array([map_name_to_int[o.name] for o in observable.obs])\n",
" target_locs = np.array([o.wires[0] for o in observable.obs])\n",
"\n",
" # perform median of means to return the result\n",
" means = []\n",
" meas_list, obs_lists = shadow\n",
" for i in range(0, shadow_size, shadow_size // k):\n",
" meas_list_k, obs_lists_k = (\n",
" meas_list[i : i + shadow_size // k],\n",
" obs_lists[i : i + shadow_size // k],\n",
" )\n",
" indices = np.all(obs_lists_k[:, target_locs] == target_obs, axis=1)\n",
" if sum(indices):\n",
" means.append(\n",
" np.sum(np.prod(meas_list_k[indices][:, target_locs], axis=1)) / sum(indices)\n",
" )\n",
" else:\n",
" means.append(0)\n",
"\n",
" return np.median(means)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "MJrMeks1lMUI"
},
"source": [
"Now we estimate the correlation matrix $C^{\\prime}$ from the classical\n",
"shadow approximation of the ground state.\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"id": "rjSaQJwYlMUI"
},
"outputs": [],
"source": [
"coups = list(it.product(range(num_qubits), repeat=2))\n",
"corrs = [corr_function(i, j) for i, j in coups]\n",
"qbobs = [qob for qobs in corrs for qob in qobs]\n",
"\n",
"def build_estim_corrmat(coups, corrs, num_obs, shadow):\n",
" k = int(2 * np.log(2 * num_obs)) # group size\n",
" corr_mat_estim = np.zeros((num_qubits, num_qubits))\n",
" for idx, (i, j) in enumerate(coups):\n",
" corr = corrs[idx]\n",
" if i == j:\n",
" corr_mat_estim[i][j] = 1.0\n",
" else:\n",
" corr_mat_estim[i][j] = (\n",
" np.sum(np.array([estimate_shadow_obs(shadow, o, k=k+1) for o in corr])) / 3\n",
" )\n",
" corr_mat_estim[j][i] = corr_mat_estim[i][j]\n",
" return corr_mat_estim\n",
"\n",
"shadow = gen_class_shadow(circuit_oshot, psi0, 10000, num_qubits)\n",
"expval_estmt = build_estim_corrmat(coups, corrs, len(qbobs), shadow)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AtpcKs2dlMUJ"
},
"source": [
"This time, let us visualize the deviation observed between the exact\n",
"correlation matrix ($C$) and the estimated correlation matrix\n",
"($C^{\\prime}$) to assess the effectiveness of classical shadow\n",
"formalism.\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 371
},
"id": "MAviSXyklMUJ",
"outputId": "480e752c-e3cb-4317-bd58-7c2a794d1fba"
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 420x400 with 2 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"fig, ax = plt.subplots(1, 1, figsize=(4.2, 4))\n",
"im = ax.imshow(expval_exact-expval_estmt, cmap=plt.get_cmap(\"RdBu\"), vmin=-1, vmax=1)\n",
"ax.xaxis.set_ticks(range(num_qubits))\n",
"ax.yaxis.set_ticks(range(num_qubits))\n",
"ax.xaxis.set_tick_params(labelsize=14)\n",
"ax.yaxis.set_tick_params(labelsize=14)\n",
"ax.set_title(\"Error in estimating the\\ncorrelation matrix\", fontsize=14)\n",
"\n",
"bar = fig.colorbar(im, pad=0.05, shrink=0.80)\n",
"bar.set_label(r\"$\\Delta C_{ij}$\", fontsize=14, rotation=0)\n",
"bar.ax.tick_params(labelsize=14)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "CvaBmbD-lMUJ"
},
"source": [
"Training Classical Machine Learning Models\n",
"==========================================\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "P9L3yo0tlMUJ"
},
"source": [
"There are multiple ways in which we can combine classical shadows and\n",
"machine learning. This could include training a model to learn the\n",
"classical representation of quantum systems based on some system\n",
"parameter, estimating a property from such learned classical\n",
"representations, or a combination of both. In our case, we consider the\n",
"problem of using\n",
"`kernel-based models <tutorial_kernel_based_training>`{.interpreted-text\n",
"role=\"doc\"} to learn the ground-state representation of the Heisenberg\n",
"model Hamiltonian $H(x_l)$ from the coupling vector $x_l$, where\n",
"$x_l = [J_{i,j} \\text{ for } i < j]$. The goal is to predict the\n",
"correlation functions $C_{ij}$:\n",
"\n",
"$$\\big\\{x_l \\rightarrow \\sigma_T(\\rho(x_l)) \\rightarrow \\text{Tr}(\\hat{C}_{ij} \\sigma_T(\\rho(x_l))) \\big\\}_{l=1}^{N}.$$\n",
"\n",
"Here, we consider the following kernel-based machine learning model:\n",
"\n",
"$$\\hat{\\sigma}_{N} (x) = \\sum_{l=1}^{N} \\kappa(x, x_l)\\sigma_T (x_l) = \\sum_{l=1}^{N} \\left(\\sum_{l^{\\prime}=1}^{N} k(x, x_{l^{\\prime}})(K+\\lambda I)^{-1}_{l, l^{\\prime}} \\sigma_T(x_l) \\right),$$\n",
"\n",
"where $\\lambda > 0$ is a regularization parameter in cases when $K$ is\n",
"not invertible, $\\sigma_T(x_l)$ denotes the classical representation of\n",
"the ground state $\\rho(x_l)$ of the Heisenberg model constructed using\n",
"$T$ randomized Pauli measurements, and $K_{ij}=k(x_i, x_j)$ is the\n",
"kernel matrix with $k(x, x^{\\prime})$ as the kernel function.\n",
"\n",
"Similarly, estimating an expectation value on the predicted ground state\n",
"$\\sigma_T(x_l)$ using the trained model can then be done by evaluating:\n",
"\n",
"$$\\text{Tr}(\\hat{O} \\hat{\\sigma}_{N} (x)) = \\sum_{l=1}^{N} \\kappa(x, x_l)\\text{Tr}(O\\sigma_T (x_l)).$$\n",
"\n",
"We train the classical kernel-based models using $N = 70$ randomly\n",
"chosen values of the coupling matrices $J$.\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"id": "awX0qjXKlMUJ"
},
"outputs": [],
"source": [
"# imports for ML methods and techniques\n",
"from sklearn.model_selection import train_test_split, cross_val_score\n",
"from sklearn import svm\n",
"from sklearn.kernel_ridge import KernelRidge"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "bQWsJyqGlMUJ"
},
"source": [
"First, to build the dataset, we use the function `build_dataset` that\n",
"takes as input the size of the dataset (`num_points`), the topology of\n",
"the lattice (`Nr` and `Nc`), and the number of randomized Pauli\n",
"measurements ($T$) for the construction of classical shadows. The\n",
"`X_data` is the set of coupling vectors that are defined as a stripped\n",
"version of the coupling matrix $J$, where only non-duplicate and\n",
"non-zero $J_{ij}$ are considered. The `y_exact` and `y_clean` are the\n",
"set of correlation vectors, i.e., the flattened correlation matrix $C$,\n",
"computed with respect to the ground-state obtained from exact\n",
"diagonalization and classical shadow representation (with $T=500$),\n",
"respectively.\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "oNjK4cvrlMUJ",
"outputId": "7e2a51c8-2864-49be-949c-6d0aa9997077"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"((100, 4), (100, 16), (100, 16))"
]
},
"metadata": {},
"execution_count": 23
}
],
"source": [
"def build_dataset(num_points, Nr, Nc, T=500):\n",
"\n",
" num_qubits = Nr * Nc\n",
" X, y_exact, y_estim = [], [], []\n",
" coupling_mats = build_coupling_mats(num_points, Nr, Nc)\n",
"\n",
" for coupling_mat in coupling_mats:\n",
" ham = Hamiltonian(coupling_mat)\n",
" eigvals, eigvecs = sp.sparse.linalg.eigs(ham.sparse_matrix())\n",
" psi = eigvecs[:, np.argmin(eigvals)]\n",
" shadow = gen_class_shadow(circuit_oshot, psi, T, num_qubits)\n",
"\n",
" coups = list(it.product(range(num_qubits), repeat=2))\n",
" corrs = [corr_function(i, j) for i, j in coups]\n",
" qbobs = [x for sublist in corrs for x in sublist]\n",
"\n",
" expval_exact = build_exact_corrmat(coups, corrs, circuit_exact, psi)\n",
" expval_estim = build_estim_corrmat(coups, corrs, len(qbobs), shadow)\n",
"\n",
" coupling_vec = []\n",
" for coup in coupling_mat.reshape(1, -1)[0]:\n",
" if coup and coup not in coupling_vec:\n",
" coupling_vec.append(coup)\n",
" coupling_vec = np.array(coupling_vec) / np.linalg.norm(coupling_vec)\n",
"\n",
" X.append(coupling_vec)\n",
" y_exact.append(expval_exact.reshape(1, -1)[0])\n",
" y_estim.append(expval_estim.reshape(1, -1)[0])\n",
"\n",
" return np.array(X), np.array(y_exact), np.array(y_estim)\n",
"\n",
"X, y_exact, y_estim = build_dataset(100, Nr, Nc, 500)\n",
"X_data, y_data = X, y_estim\n",
"X_data.shape, y_data.shape, y_exact.shape"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "V18wEzs_lMUK"
},
"source": [
"Now that our dataset is ready, we can shift our focus to the ML models.\n",
"Here, we use two different Kernel functions: (i) Gaussian Kernel and\n",
"(ii) Neural Tangent Kernel. For both of them, we consider the\n",
"regularization parameter $\\lambda$ from the following set of values:\n",
"\n",
"$$\\lambda = \\left\\{ 0.0025, 0.0125, 0.025, 0.05, 0.125, 0.25, 0.5, 1.0, 5.0, 10.0 \\right\\}.$$\n",
"\n",
"Next, we define the kernel functions $k(x, x^{\\prime})$ for each of the\n",
"mentioned kernels:\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Seuq-zVflMUK"
},
"source": [
"$$k(x, x^{\\prime}) = e^{-\\gamma||x - x^{\\prime}||^{2}_{2}}. \\tag{Gaussian Kernel}$$\n",
"\n",
"For the Gaussian kernel, the hyperparameter\n",
"$\\gamma = N^{2}/\\sum_{i=1}^{N} \\sum_{j=1}^{N} ||x_i-x_j||^{2}_{2} > 0$\n",
"is chosen to be the inverse of the average Euclidean distance $x_i$ and\n",
"$x_j$. The kernel is implemented using the radial-basis function (rbf)\n",
"kernel in the `sklearn` library.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "38VnvOMGlMUK"
},
"source": [
"$$k(x, x^{\\prime}) = k^{\\text{NTK}}(x, x^{\\prime}). \\tag{Neural Tangent Kernel}$$\n",
"\n",
"The neural tangent kernel $k^{\\text{NTK}}$ used here is equivalent to an\n",
"infinite-width feed-forward neural network with four hidden layers and\n",
"that uses the rectified linear unit (ReLU) as the activation function.\n",
"This is implemented using the `neural_tangents` library.\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"id": "Ekn9atIZlMUK"
},
"outputs": [],
"source": [
"from neural_tangents import stax\n",
"init_fn, apply_fn, kernel_fn = stax.serial(\n",
" stax.Dense(32),\n",
" stax.Relu(),\n",
" stax.Dense(32),\n",
" stax.Relu(),\n",
" stax.Dense(32),\n",
" stax.Relu(),\n",
" stax.Dense(32),\n",
" stax.Relu(),\n",
" stax.Dense(1),\n",
")\n",
"kernel_NN = kernel_fn(X_data, X_data, \"ntk\")\n",
"\n",
"for i in range(len(kernel_NN)):\n",
" for j in range(len(kernel_NN)):\n",
" kernel_NN.at[i, j].set((kernel_NN[i][i] * kernel_NN[j][j]) ** 0.5)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "GJbMkW7klMUK"
},
"source": [
"For the above two defined kernel methods, we obtain the best learning\n",
"model by performing hyperparameter tuning using cross-validation for the\n",
"prediction task of each $C_{ij}$. For this purpose, we implement the\n",
"function `fit_predict_data`, which takes input as the correlation\n",
"function index `cij`, kernel matrix `kernel`, and internal kernel\n",
"mapping `opt` required by the kernel-based regression models from the\n",
"`sklearn` library.\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"id": "7qbJKRGglMUK"
},
"outputs": [],
"source": [
"from sklearn.metrics import mean_squared_error\n",
"\n",
"def fit_predict_data(cij, kernel, opt=\"linear\"):\n",
"\n",
" # training data (estimated from measurement data)\n",
" y = np.array([y_estim[i][cij] for i in range(len(X_data))])\n",
" X_train, X_test, y_train, y_test = train_test_split(\n",
" kernel, y, test_size=0.3, random_state=24\n",
" )\n",
"\n",
" # testing data (exact expectation values)\n",
" y_clean = np.array([y_exact[i][cij] for i in range(len(X_data))])\n",
" _, _, _, y_test_clean = train_test_split(kernel, y_clean, test_size=0.3, random_state=24)\n",
"\n",
" # hyperparameter tuning with cross validation\n",
" models = [\n",
" # Epsilon-Support Vector Regression\n",
" (lambda Cx: svm.SVR(kernel=opt, C=Cx, epsilon=0.1)),\n",
" # Kernel-Ridge based Regression\n",
" (lambda Cx: KernelRidge(kernel=opt, alpha=1 / (2 * Cx))),\n",
" ]\n",
"\n",
" # Regularization parameter\n",
" hyperparams = [0.0025, 0.0125, 0.025, 0.05, 0.125, 0.25, 0.5, 1.0, 5.0, 10.0]\n",
" best_pred, best_cv_score, best_test_score = None, np.inf, np.inf\n",
" for model in models:\n",
" for hyperparam in hyperparams:\n",
" cv_score = -np.mean(\n",
" cross_val_score(\n",
" model(hyperparam), X_train, y_train, cv=5,\n",
" scoring=\"neg_root_mean_squared_error\",\n",
" )\n",
" )\n",
" if best_cv_score > cv_score:\n",
" best_model = model(hyperparam).fit(X_train, y_train)\n",
" best_pred = best_model.predict(X_test)\n",
" best_cv_score = cv_score\n",
" best_test_score = mean_squared_error(\n",
" best_model.predict(X_test).ravel(), y_test_clean.ravel(), squared=False\n",
" )\n",
"\n",
" return (\n",
" best_pred, y_test_clean, np.round(best_cv_score, 5), np.round(best_test_score, 5)\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "IGPcW5sglMUK"
},
"source": [
"We perform the fitting and prediction for each $C_{ij}$ and print the\n",
"output in a tabular format.\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "vxZOUxk9lMUK",
"outputId": "93026c38-5ab2-4e7f-93c2-99a2fc0856a3"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" Correlation Gaussian kernel Neural Tangent kernel\n",
" \t C_00 \t| [-0. 0.] [-0. 0.]\n",
" \t C_01 \t| [0.09871 0.06988] [0.12886 0.06494]\n",
" \t C_02 \t| [0.10078 0.06333] [0.10897 0.07771]\n",
" \t C_03 \t| [0.09489 0.0417 ] [0.10066 0.05993]\n",
" \t C_10 \t| [0.09871 0.06988] [0.12886 0.06494]\n",
" \t C_11 \t| [-0. 0.] [-0. 0.]\n",
" \t C_12 \t| [0.11153 0.03719] [0.11597 0.05878]\n",
" \t C_13 \t| [0.1052 0.0649] [0.11276 0.08506]\n",
" \t C_20 \t| [0.10078 0.06333] [0.10897 0.07771]\n",
" \t C_21 \t| [0.11153 0.03719] [0.11597 0.05878]\n",
" \t C_22 \t| [-0. 0.] [-0. 0.]\n",
" \t C_23 \t| [0.10534 0.07744] [0.12772 0.10248]\n",
" \t C_30 \t| [0.09489 0.0417 ] [0.10066 0.05993]\n",
" \t C_31 \t| [0.1052 0.0649] [0.11276 0.08506]\n",
" \t C_32 \t| [0.10534 0.07744] [0.12772 0.10248]\n",
" \t C_33 \t| [-0. 0.] [-0. 0.]\n"
]
}
],
"source": [
"kernel_list = [\"Gaussian kernel\", \"Neural Tangent kernel\"]\n",
"kernel_data = np.zeros((num_qubits ** 2, len(kernel_list), 2))\n",
"y_predclean, y_predicts1, y_predicts2 = [], [], []\n",
"\n",
"for cij in range(num_qubits ** 2):\n",
" y_predict, y_clean, cv_score, test_score = fit_predict_data(cij, X_data, opt=\"rbf\")\n",
" y_predclean.append(y_clean)\n",
" kernel_data[cij][0] = (cv_score, test_score)\n",
" y_predicts1.append(y_predict)\n",
" y_predict, y_clean, cv_score, test_score = fit_predict_data(cij, kernel_NN)\n",
" kernel_data[cij][1] = (cv_score, test_score)\n",
" y_predicts2.append(y_predict)\n",
"\n",
"# For each C_ij print (best_cv_score, test_score) pair\n",
"row_format = \"{:>25}{:>35}{:>35}\"\n",
"print(row_format.format(\"Correlation\", *kernel_list))\n",
"for idx, data in enumerate(kernel_data):\n",
" print(\n",
" row_format.format(\n",
" f\"\\t C_{idx//num_qubits}{idx%num_qubits} \\t| \",\n",
" str(data[0]),\n",
" str(data[1]),\n",
" )\n",
" )"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "W8OQJN7blMUK"
},
"source": [
"Overall, we find that the models with the Gaussian kernel performed\n",
"better than those with NTK for predicting the expectation value of the\n",
"correlation function $C_{ij}$ for the ground state of the Heisenberg\n",
"model. However, the best choice of $\\lambda$ differed substantially\n",
"across the different $C_{ij}$ for both kernels. We present the predicted\n",
"correlation matrix $C^{\\prime}$ for randomly selected Heisenberg models\n",
"from the test set below for comparison against the actual correlation\n",
"matrix $C$, which is obtained from the ground state found using exact\n",
"diagonalization.\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 930
},
"id": "EpnjzM4WlMUK",
"outputId": "a7c33db4-cd54-417c-e672-5bd9170ac651"
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 1400x1400 with 10 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"fig, axes = plt.subplots(3, 3, figsize=(14, 14))\n",
"corr_vals = [y_predclean, y_predicts1, y_predicts2]\n",
"plt_plots = [1, 14, 25]\n",
"\n",
"cols = [\n",
" \"From {}\".format(col)\n",
" for col in [\"Exact Diagonalization\", \"Gaussian Kernel\", \"Neur. Tang. Kernel\"]\n",
"]\n",
"rows = [\"Model {}\".format(row) for row in plt_plots]\n",
"\n",
"for ax, col in zip(axes[0], cols):\n",
" ax.set_title(col, fontsize=18)\n",
"\n",
"for ax, row in zip(axes[:, 0], rows):\n",
" ax.set_ylabel(row, rotation=90, fontsize=24)\n",
"\n",
"for itr in range(3):\n",
" for idx, corr_val in enumerate(corr_vals):\n",
" shw = axes[itr][idx].imshow(\n",
" np.array(corr_vals[idx]).T[plt_plots[itr]].reshape(Nr * Nc, Nr * Nc),\n",
" cmap=plt.get_cmap(\"RdBu\"), vmin=-1, vmax=1,\n",
" )\n",
" axes[itr][idx].xaxis.set_ticks(range(Nr * Nc))\n",
" axes[itr][idx].yaxis.set_ticks(range(Nr * Nc))\n",
" axes[itr][idx].xaxis.set_tick_params(labelsize=18)\n",
" axes[itr][idx].yaxis.set_tick_params(labelsize=18)\n",
"\n",
"fig.subplots_adjust(right=0.86)\n",
"cbar_ax = fig.add_axes([0.90, 0.15, 0.015, 0.71])\n",
"bar = fig.colorbar(shw, cax=cbar_ax)\n",
"\n",
"bar.set_label(r\"$C_{ij}$\", fontsize=18, rotation=0)\n",
"bar.ax.tick_params(labelsize=16)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "EY4jZ8bPlMUK"
},
"source": [
"Finally, we also attempt to showcase the effect of the size of training\n",
"data $N$ and the number of Pauli measurements $T$. For this, we look at\n",
"the average root-mean-square error (RMSE) in prediction for each kernel\n",
"over all two-point correlation functions $C_{ij}$. Here, the first plot\n",
"looks at the different training sizes $N$ with a fixed number of\n",
"randomized Pauli measurements $T=100$. In contrast, the second plot\n",
"looks at the different shadow sizes $T$ with a fixed training data size\n",
"$N=70$. The performance improvement seems to be saturating after a\n",
"sufficient increase in $N$ and $T$ values for all two kernels in both\n",
"the cases.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "E2XL6tE-lMUK"
},
"source": [
"{width=\"47.0%\"}\n",
"\n",
"{width=\"47.0%\"}\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "NGuMg3dVlMUK"
},
"source": [
"Conclusion\n",
"==========\n",
"\n",
"This demo illustrates how classical machine learning models can benefit\n",
"from the classical shadow formalism for learning characteristics and\n",
"predicting the behavior of quantum systems. As argued in Ref., this\n",
"raises the possibility that models trained on experimental or quantum\n",
"data data can effectively address quantum many-body problems that cannot\n",
"be solved using classical methods alone.\n"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "0DVGzrBtG3Op",
"outputId": "ba7e1dd9-73f3-4012-922e-d4c60d2a8d6e"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Time in seconds since end of run: 1700501668.4348798\n",
"Mon Nov 20 17:34:28 2023\n"
]
}
],
"source": [
"seconds = time.time()\n",
"print(\"Time in seconds since end of run:\", seconds)\n",
"local_time = time.ctime(seconds)\n",
"print(local_time)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hkYS-zIJlMUL"
},
"source": [
"References {#ml_classical_shadow_references}\n",
"==========\n",
"\n",
"About the author\n",
"================\n"
]
}
],
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.8"
}
},
"nbformat": 4,
"nbformat_minor": 0
}